/*
 * test.js
 * @Author: keyman
 * @Date:   2025-10-11
 */

/*
 *  1.手写冒泡排序
 */
function bubbleSort(arr) {
    for (let i = 0; i < arr.length; i++) {
        for (let j = 0; j < arr.length - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
            }
        }
    }
    return arr;
}

/*
 *  2.手写new关键字源码
 */
function myNew(fn, ...args) {
    const obj = Object.create(fn.prototype);
    const res = fn.apply(obj, args);
    return res instanceof Object ? res : obj;
}

function Student(name,age) {
    this.name = name;
    this.age = age;
}

console.log(myNew( Student,'keyman',18))

/*
 *  3.手写instanceof源码
 *  instanceof原理：
 *  1.判断构造函数的prototype属性是否出现在对象的原型链上
 *  2.判断对象是否为构造函数的实例
 */

function myInstanceof(obj, fn) {
    // 基本类型直接返回 false
    if ((typeof obj !=='object'&& typeof fn !=='function')||obj === null|| fn === null){
        return false;
    }

    // 遍历原型链
    let proto = Object.getPrototypeOf( obj);
    while (proto) {
        if (proto === fn.prototype) {
            return true;
        }
        proto = Object.getPrototypeOf(proto);
    }

    return false;


}

/*
 *  4.手写防抖和节流
 */
function debounce(fn, delay) {
    // 防抖函数
    let timer = null;
    return function (){
        clearTimeout(timer);
        timer = setTimeout(() => {
            fn();
        }, delay)
    }
}

function throttle(fn, delay) {
    let timer = null;
    return function () {
        if (!timer) {
            timer = setTimeout(() => {
                fn();
                timer = null;
            }, delay)
        }
    }
}

function shallowClone(obj) {
    // 浅拷贝
    // 利用拓展运算符
    return [...obj]
}

function deepClone(obj) {
    // 深拷贝
    // 判空
    if (obj === null) return obj;

    // 如果传入的对象不是普通对象（即不是对象类型）或普通的值 如果是函数的话就不需要深拷贝
    if (typeof obj !== 'object') return obj;

    // 创建一个新对象，这个新对象和obj对象类型相同
    // 找到的是所属类原型上的constructor属性，而原型上的constructor指向的是当前类本身
    let newObj = new obj.constructor();
    for (let item in obj) {
        // 判断该对象是否存在该属性，不包括继承属性
        if (obj.hasOwnProperty(item)) {
            // 递归调用
            newObj[item] = deepClone(obj[item]);
        }
    }
    return newObj;
}

function ajax(ev, url, type, ...data) {
    // 创建 ajax 对象
    let xhr = new XMLHttpRequest();
    // 建立连接
    xhr.open(type,url);
    // 发送数据
    if (type === 'POST') {
        xhr.setRequestHeader('Content-Type', 'application/json');
        xhr.send(JSON.stringify(data));
    } else {
        xhr.send();
    }
    // 监听状态
    xhr.onreadystatechange = (ev)=>{
        if (xhr.readyState === 4 && xhr.status === 200) {
            console.log(xhr.responseText);
        }else {
            console.log('请求失败');
        }
    }
}


